home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 April: Mac OS SDK / Dev.CD Apr 97 SDK1.toast / Development Kits (Disc 1) / Installer SDK Cornucopia 1.0.2 / Script Examples / File Compression⁄Split Example / fileCompressSplit.r < prev    next >
Encoding:
Text File  |  1996-09-30  |  20.6 KB  |  580 lines  |  [TEXT/MPS ]
  1. //
  2. //    fileCompress.r    - an example of how to use InstaCompOne compression
  3. //
  4. //
  5. //    How To Build the Script:
  6. //    
  7. //        To build Installer script access "Build…" item within "Build" menu
  8. //        and enter the scriptName "fileCompress". To build the Installer
  9. //        debugger version of the Installer script enter the scriptname
  10. //        with the addition ".debug" ( "fileCompress.debug" ).
  11. //
  12. //        There must be a copy of the file "InstaCompOneSCExt.rsrc"
  13. //        that has been renamed to "fileCompress.scx" included in this
  14. //        folder as well. This file will automatically be copied and
  15. //        renamed ( from the InstaCompOne folder in the SDK ) when the
  16. //        makefile for this example is run.
  17. //
  18. //    What this example does :
  19. //
  20. //        This Installer script source demonstrates use of InstaCompOne 
  21. //        archives, split files, the InstaCompOneTool compression utility, 
  22. //        and the FileAndRsrcSplitterTool for use in installing files.
  23. //
  24. //        All target files from example installations are placed in a folder 
  25. //        called ":InstaComp Testing:" on the root folder of the target volume 
  26. //        of installation. Performing a "GetInfo" on the resulting file(s) will 
  27. //        display information identifying from which method the file was installed.
  28. //        The three methods are: file compression, file splitting, file compression
  29. //        and splitting.
  30. //
  31. //    IMPORTANT: You must use the flag "rsrcForkInDataFork" in file atoms when using
  32. //    InstaCompOne to compress files. This enables the Installer to find the compressed
  33. //    resource fork in the data fork of the archive file.
  34. //
  35. //    NOTE: InstaCompOne can be used to split and compress resources and fonts 
  36. //    in addition to files, but this example deals only with splitting and 
  37. //    compressing files. The major difference between working with files and 
  38. //    working with resources ( and fonts ) is that compressed items will usually 
  39. //    be stored in the data fork of an archive when working with files and will 
  40. //    be stored in the resource fork of an archive when working with resources 
  41. //    and fonts.
  42. //
  43. //
  44. //    The following MPW commands for compression and splitting are already
  45. //    contained in the makefile for this example.  They have been included 
  46. //    here for your convenience.  Running the makefile will demonstrate all
  47. //    the commands listed below.
  48. //
  49. //  • simple file compression example ( no splitting )
  50. //
  51. //    - To compress "Example File • 1" into an archive called "Tome" within "Disk 1:"
  52. //    InstaCompOneTool "Example File • 1" -o ":Disk 1:Tome"
  53. //
  54. //
  55. //    • split and compressed file example
  56. //
  57. //    - To split our file into two resource forks :
  58. //    FileAndRsrcSplitterTool "Example File • 2" -s 1650 -o "splitCompReadMe"
  59. //    - The above line specifies that the maximum size for any split piece be 1650 bytes.
  60. //      Such a small size was specified since our example file is so small.
  61. //    Normally, you will want the maximum size to be much larger.
  62. //    - This split will result in three files within the current folder
  63. //      named "splitCompReadMe.rsrc1", "splitCompReadMe.rsrc2", "splitCompReadMe.data1"
  64. //  - IMPORTANT: The FileAndRsrcSplitterTool will create a separate file for the orginal
  65. //    file's data fork. If your original file has a data fork, you will also need to
  66. //    create two 'infa's, one to copy the resource fork and anothe to copy the data fork.
  67. //
  68. //    - To compress the first split piece into an archive in ":Disk 1:"
  69. //    InstaCompOneTool "splitCompReadMe.rsrc1" -o ":Disk 1:splitCompTome1" -f "Example File • 2" -e
  70. //
  71. //    - To compress the second split piece into an archive in ":Disk 2:"
  72. //    InstaCompOneTool "splitCompReadMe.rsrc2" -o ":Disk 2:splitCompTome2" -f "Example File • 2" -e
  73.  
  74. //    - To compress the data fork split piece into an archive in ":Disk 2:"
  75. //    InstaCompOneTool "splitCompReadMe.rsrc2" -o ":Disk 2:splitCompTome3" -f "Example File • 2"
  76. //  - IMPORTANT: Notice that we do not specify the "-e" option when compressing the data fork.
  77. //
  78. //    • simple split file example ( no compression )
  79. //
  80. //    - To split a file into two resource forks (and one data fork):
  81. //    FileAndRsrcSplitterTool "Example File • 3" -s 1650 -o "splitReadMe"
  82. //    - this will result in three files within the current folder
  83. //    - named "splitReadMe.rsrc1", "splitReadMe.rsrc2", and "splitReadMe.data1"
  84. //
  85. //    - To place both these pieces in the installation disk folders :
  86. //    Duplicate "splitReadMe.rsrc1" -y ":Disk 1:splitTome1"
  87. //    Duplicate "splitReadMe.rsrc2" -y ":Disk 2:splitTome2"
  88. //    Duplicate "splitReadMe.data1" -y ":Disk 2:splitTome3"
  89. //
  90. //
  91. //
  92. //
  93. //    NOTE: Always use the target filename ( contained in the target file 
  94. //    spec 'intf' ) when compressing a file into an archive. This will 
  95. //    ensure that the InstaCompOne decompression utility can successfully 
  96. //    locate and decompress the contents of the archive during installation. 
  97. //    A full target path for the destination file should be entered in the 
  98. //    'intf' resource, but only the actual filename will be used when extracting 
  99. //    compressed file items from within an archive.
  100. //
  101. //     NOTE: When using InstaCompOne compression and splitting, simply enter 241
  102. //     as the value for the atom extender ( 'inex' ) in the next to last field
  103. //     of the atom ( 'infa', 'inff', 'inra' ) for the file/font/rsrc to be
  104. //     decompressed.  There is no need to declare an 'inex' resource within the
  105. //     Installer script source.  An 'inex' resource definition is contained in
  106. //     the InstaCompOne resource file that is included at the top of this file.
  107. //
  108. //
  109. //
  110. //        Copyright 1993-1996, Apple Computer, Inc., All Rights Reserved
  111. //
  112.  
  113. #include "InstallerTypes.r"
  114.  
  115. // Include the InstaCompOne atom extender stuff
  116. // making sure not to add their version resource
  117. // to our installer script. Also, since this include
  118. // is a resource include instead of a #include, it is
  119. // not actually a pre-processor thing, and won't be effected
  120. // by a -i option within the rez line in the makefile. 
  121. include ":::Tools:Released:InstaCompOne 1.1:InstaCompAtomExt.rsrc" NOT 'vers';
  122.  
  123.  
  124. // • packages
  125.  
  126. // package that demonstrates simple case of archive, 
  127. //    one file in archive decompressed to target volume
  128. resource 'inpk' (100) {
  129.     format0 {
  130.         showsOnCustom,
  131.         removable,
  132.         dontForceRestart,
  133.         0,
  134.         0,
  135.         "Example File - using InstaCompOne compression.",
  136.         {    
  137.         'infa', 1000;
  138.         },
  139.     }
  140. };
  141.  
  142. // package that demonstrates decompressing two archives and 
  143. //    joining the results into one target file
  144. resource 'inpk' (200) {
  145.     format0 {
  146.         showsOnCustom,
  147.         removable,
  148.         dontForceRestart,
  149.         0,
  150.         0,
  151.         "Example File - using file splitting and InstaCompOne compression.",
  152.         {    
  153.         'infa', 2000;                // resource fork
  154.         'infa', 2002;                // data fork
  155.         },
  156.     }
  157. };
  158.  
  159. // package that demonstrates decompressing two archives and 
  160. //    joining the results into one target file
  161. resource 'inpk' (300) {
  162.     format0 {
  163.         showsOnCustom,
  164.         removable,
  165.         dontForceRestart,
  166.         0,
  167.         0,
  168.         "Example File - using file splitting, but no compression.",
  169.         {    
  170.         'infa', 3000;                // resource fork
  171.         'infa', 3003;                // data fork
  172.         },
  173.     }
  174. };
  175.  
  176.  
  177. // • file atoms
  178.  
  179. // • simple compression example
  180. // single source file => single archive => single target file
  181. resource 'infa' (1000) {
  182.     format1 {
  183.         deleteWhenRemoving,                //  Delete on deinstall
  184.         deleteWhenInstalling,            //  Remove preexisting
  185.         copy,                            //  Copy on Install
  186.         dontIgnoreLockedFile,            //  Respect file locking
  187.         dontSetFileLocked,                //  Leave installed file unlocked
  188.         useSrcCrDateToCompare,            //  Use creation date for compare
  189.         srcNeedNotExist,                //  Create a new file if necessary
  190.         
  191.         // this line must be set to "rsrcForkInDataFork" when working 
  192.         // file items compressed into InstaCompOne archives
  193.         rsrcForkInDataFork,                //  • Resource fork in Data fork
  194.         
  195.         leaveAloneIfNewer,                //  Do not update a newer file
  196.         updateExisting,                    //  Update an existing file
  197.         copyIfNewOrUpdate,                //  Copy whether target exists or not
  198.         rsrcFork,                        //  Copy resource fork
  199.         dataFork,                        //  Copy data fork
  200.         
  201.         0,                    // TARGET - size ( filled in by ScriptCheck )
  202.         0x0,                // finder attribute flags ( filled in by ScriptCheck )
  203.         10000,                // TARGET - file spec ( 'intf' )
  204.         {    
  205.             10001,            // SOURCE - file spec ( 'infs' )
  206.             0,                 // DATA fork - size ( filled in by ScriptCheck )
  207.             0                // RSRC fork - size ( filled in by ScriptCheck )
  208.         },    
  209.         
  210.         0x0,                // SOURCE - version number for comparisons
  211.                             // not used here
  212.                             
  213.         0,                    // 'invc' code resource - version comparison routine 
  214.                             //    ( none used here )
  215.         
  216.         241,                // 'inex' resource definition for atom extender
  217.                             // • #241 is for InstaCompOne extender
  218.                             
  219.         "Example File • 1"        // file atom description
  220.     }
  221. };
  222.  
  223.  
  224. // • split file compression example
  225. // • file atom for resource fork
  226. // single source file => split resource fork => 2 resource archives => single target file
  227. resource 'infa' (2000) {
  228.     format1 {
  229.         deleteWhenRemoving,                //  Delete on deinstall
  230.         deleteWhenInstalling,            //  Remove preexisting
  231.         copy,                            //  Copy on Install
  232.         dontIgnoreLockedFile,            //  Respect file locking
  233.         dontSetFileLocked,                //  Leave installed file unlocked
  234.         useSrcCrDateToCompare,            //  Use creation date for compare
  235.         srcNeedExist,                    //  Require a source file
  236.         
  237.         // this line must be set to "rsrcForkInDataFork" when working 
  238.         // file items compressed into InstaCompOne archives
  239.         rsrcForkInDataFork,                //  • Resource fork in Data fork
  240.         
  241.         leaveAloneIfNewer,                //  Do not update a newer file
  242.         updateExisting,                    //  Update an existing file
  243.         copyIfNewOrUpdate,                //  Copy whether target exists or not
  244.         rsrcFork,                        //  Copy resource fork
  245.         dataFork,                        //  Copy data fork
  246.         
  247.         0,                    // TARGET - size ( filled in by ScriptCheck )
  248.         0x0,                // finder attribute flags ( filled in by ScriptCheck )
  249.         20000,                // TARGET - file spec ( 'intf' )
  250.         {    
  251.             // • IMPORTANT - the split and compressed pieces must be listed
  252.             // • in the same order here as when they were split. In other
  253.             // • words the piece that was split off first ( and was given
  254.             // • the ".rsrc1" ending ) should be listed first in the lines below.
  255.             // • then comes the piece with the ".rsrc2" ending, etc.
  256.             
  257.             20001,            // SOURCE - file spec ( 'infs' )
  258.             0,                 // DATA fork - size ( filled in by ScriptCheck )
  259.             0,                // RSRC fork - size ( filled in by ScriptCheck )
  260.             
  261.             20002,            // SOURCE - file spec ( 'infs' )
  262.             0,                 // DATA fork - size ( filled in by ScriptCheck )
  263.             0,                // RSRC fork - size ( filled in by ScriptCheck )
  264.         },    
  265.         
  266.         0x0,                // SOURCE - version number for comparisons,
  267.                             // not used here
  268.                             
  269.         0,                    // 'invc' code resource - version comparison routine 
  270.                             //    ( none used here )
  271.         
  272.         
  273.         241,                // 'inex' resource definition for atom extender
  274.                             // • #241 is for InstaCompOne extender
  275.                             
  276.         "Example File • 2"        // file atom description
  277.     }
  278. };
  279.  
  280. // • file atom for data fork
  281. // single source file => split data fork => data fork archive => single target file
  282. resource 'infa' (2002) {
  283.     format1 {
  284.         deleteWhenRemoving,                //  Delete on deinstall
  285.         deleteWhenInstalling,            //  Remove preexisting
  286.         copy,                            //  Copy on Install
  287.         dontIgnoreLockedFile,            //  Respect file locking
  288.         dontSetFileLocked,                //  Leave installed file unlocked
  289.         useSrcCrDateToCompare,            //  Use creation date for compare
  290.         srcNeedExist,                    //  Require a source file
  291.         
  292.         // this line must be set to "rsrcForkInDataFork" when working 
  293.         // file items compressed into InstaCompOne archives
  294.         rsrcForkInDataFork,                //  • Resource fork in Data fork
  295.         
  296.         leaveAloneIfNewer,                //  Do not update a newer file
  297.         updateExisting,                    //  Update an existing file
  298.         copyIfNewOrUpdate,                //  Copy whether target exists or not
  299.         noRsrcFork,                        //  Copy resource fork
  300.         dataFork,                        //  Copy data fork
  301.         
  302.         0,                    // TARGET - size ( filled in by ScriptCheck )
  303.         0x0,                // finder attribute flags ( filled in by ScriptCheck )
  304.         20000,                // TARGET - file spec ( 'intf' )
  305.         {    
  306.             20003,            // SOURCE - file spec ( 'infs' )
  307.             0,                 // DATA fork - size ( filled in by ScriptCheck )
  308.             0                // RSRC fork - size ( filled in by ScriptCheck )
  309.         },    
  310.         
  311.         0x0,                // SOURCE - version number for comparisons,
  312.                             // not used here
  313.                             
  314.         0,                    // 'invc' code resource - version comparison routine 
  315.                             //    ( none used here )
  316.         
  317.         
  318.         0,                    // we did not compress, so there is no atom extender
  319.                             
  320.         "Example File • 2"        // file atom description
  321.     }
  322. };
  323.  
  324.  
  325.  
  326. // • split file w/o compression example
  327. // single source file => split resource fork => single target file
  328. resource 'infa' (3000) {
  329.     format1 {
  330.         deleteWhenRemoving,                //  Delete on deinstall
  331.         deleteWhenInstalling,            //  Remove preexisting
  332.         copy,                            //  Copy on Install
  333.         dontIgnoreLockedFile,            //  Respect file locking
  334.         dontSetFileLocked,                //  Leave installed file unlocked
  335.         useSrcCrDateToCompare,            //  Use creation date for compare
  336.         srcNeedExist,                    //  Require a source file
  337.         
  338.         // this line must be set to "rsrcForkInDataFork" when working 
  339.         // file items compressed into InstaCompOne archives
  340.         rsrcForkInDataFork,                //  • Resource fork in Data fork
  341.         
  342.         leaveAloneIfNewer,                //  Do not update a newer file
  343.         updateExisting,                    //  Update an existing file
  344.         copyIfNewOrUpdate,                //  Copy whether target exists or not
  345.         rsrcFork,                        //  Copy resource fork
  346.         
  347.         noDataFork,                        //  • Don't Copy data fork
  348.                                         //     'noDataFork' must be set
  349.                                         //     when splitting the resource
  350.                                         //     fork but not compressing the pieces
  351.                                         
  352.         0,                    // TARGET - size ( filled in by ScriptCheck )
  353.         0x0,                // finder attribute flags ( filled in by ScriptCheck )
  354.         30000,                // TARGET - file spec ( 'infs' )
  355.         {    
  356.             // • IMPORTANT - the split pieces must be listed in the
  357.             // • same order here as when they were split. In other
  358.             // • words the piece that was split off first ( and was given
  359.             // • the ".rsrc1" ending ) should be listed first in the lines below.
  360.             // • then comes the piece with the ".rsrc2" ending, etc.
  361.             
  362.             30001,            // SOURCE - file spec ( 'infs' )
  363.             0,                 // DATA fork - size ( filled in by ScriptCheck )
  364.             0,                // RSRC fork - size ( filled in by ScriptCheck )
  365.             
  366.             30002,            // SOURCE - file spec ( 'infs' )
  367.             0,                 // DATA fork - size ( filled in by ScriptCheck )
  368.             0,                // RSRC fork - size ( filled in by ScriptCheck )
  369.         },    
  370.         
  371.         0x0,                // SOURCE - version number for comparisons
  372.                             // not used here
  373.                             
  374.         0,                    // 'invc' code resource - version comparison routine 
  375.                             //    ( none used here )
  376.         
  377.         
  378.         0,                    // 'inex' resource definition for atom extender
  379.                             // don't use atom extender for simple split files
  380.                             
  381.         "Example File • 3"            // file atom description
  382.     }
  383. };
  384.  
  385. // • split file w/o compression example
  386. // single source file => split data fork => single target file
  387. resource 'infa' (3003) {
  388.     format1 {
  389.         deleteWhenRemoving,                //  Delete on deinstall
  390.         deleteWhenInstalling,            //  Remove preexisting
  391.         copy,                            //  Copy on Install
  392.         dontIgnoreLockedFile,            //  Respect file locking
  393.         dontSetFileLocked,                //  Leave installed file unlocked
  394.         useSrcCrDateToCompare,            //  Use creation date for compare
  395.         srcNeedExist,                    //  Require a source file
  396.         
  397.         // this line must be set to "rsrcForkInDataFork" when working 
  398.         // file items compressed into InstaCompOne archives
  399.         rsrcForkInDataFork,                //  • Resource fork in Data fork
  400.         
  401.         leaveAloneIfNewer,                //  Do not update a newer file
  402.         updateExisting,                    //  Update an existing file
  403.         copyIfNewOrUpdate,                //  Copy whether target exists or not
  404.         noRsrcFork,                        //  • Don't Copy resource fork
  405.         
  406.         dataFork,                        //  • Copy data fork
  407.                                         
  408.         0,                    // TARGET - size ( filled in by ScriptCheck )
  409.         0x0,                // finder attribute flags ( filled in by ScriptCheck )
  410.         30000,                // TARGET - file spec ( 'infs' )
  411.         {    
  412.             
  413.             30003,            // SOURCE - file spec ( 'infs' )
  414.             0,                 // DATA fork - size ( filled in by ScriptCheck )
  415.             0                // RSRC fork - size ( filled in by ScriptCheck )
  416.         },    
  417.         
  418.         0x0,                // SOURCE - version number for comparisons
  419.                             // not used here
  420.                             
  421.         0,                    // 'invc' code resource - version comparison routine 
  422.                             //    ( none used here )
  423.         
  424.         
  425.         0,                    // 'inex' resource definition for atom extender
  426.                             // don't use atom extender for simple split files
  427.                             
  428.         "Example File • 3"            // file atom description
  429.     }
  430. };
  431.  
  432.  
  433. // • compressed - file specs
  434.  
  435. // • simple compression
  436. // target file spec for decompressed "Example File" file 
  437. resource 'intf' (10000) {
  438.     format1 {
  439.         noSearchForFile,        // use default search path
  440.         TypeCrNeedNotMatch,        // target type and creator don't have to match
  441.         'ttro',                    // TYPE given to new file
  442.         'ttxt',                    // CREATOR given to new file
  443.         
  444.         0x0,                    // Target - finder flags
  445.                                 //    ( ScriptCheck fills in flags if set to 0 )
  446.         
  447.         0x1,                    // Target - creation date 
  448.         0x1,                    // Target - mod date 
  449.                                 //    ( ScriptCheck fills in dates if set to 1 )
  450.                                 
  451.         0,                        // 'insp' resource ID ( file search proc )
  452.         ":File Compression/Split Example:Example File • 1"    // path to target file
  453.     }
  454. };
  455.  
  456.  
  457. // • simple compression
  458. // source file spec for compressed "Example File" file 
  459. resource 'infs' (10001) {
  460.     'idcp',                        // TYPE 
  461.     'kakc',                        // CREATOR 
  462.     0x0,                        // creation DATE for source file
  463.     noSearchForFile,            // IGNORED in Installer 4.0.x
  464.     TypeCrMustMatch,            // TYPE, CREATOR must match file on install disk
  465.     "Disk 1:Tome"                // PATH to source file        
  466. };
  467.  
  468. // • split and compressed - file specs
  469.  
  470. // • split resource fork with compression
  471. // shared target file spec to result from joining split pieces in archives 
  472. resource 'intf' (20000) {
  473.     format1 {
  474.         noSearchForFile,        // use default search path
  475.         TypeCrNeedNotMatch,        // target type and creator don't have to match
  476.         'ttro',                    // TYPE given to new file
  477.         'ttxt',                    // CREATOR given to new file
  478.         
  479.         0x0,                    // Target - finder flags
  480.                                 //    ( ScriptCheck fills in flags if set to 0 )
  481.         
  482.         0x1,                    // Target - creation date 
  483.         0x1,                    // Target - mod date 
  484.                                 //    ( ScriptCheck fills in dates if set to 1 )
  485.                                 
  486.         0,                        // 'insp' resource ID ( file search proc )
  487.         ":File Compression/Split Example:Example File • 2"    // path to target file
  488.     }
  489. };
  490.  
  491. // • split resource fork with compression
  492. // source file spec for archive containing one piece of split file 
  493. resource 'infs' (20001) {
  494.     'idcp',                        // TYPE 
  495.     'kakc',                        // CREATOR 
  496.     0x0,                        // creation DATE for source file
  497.     noSearchForFile,            // IGNORED in Installer 4.0.x
  498.     TypeCrMustMatch,            // TYPE, CREATOR must match file on install disk
  499.     "Disk 1:splitCompTome1"        // PATH to source file        
  500. };
  501.  
  502. // • split resource fork with compression
  503. // source file spec for archive containing one piece of split file 
  504. resource 'infs' (20002) {
  505.     'idcp',                        // TYPE 
  506.     'kakc',                        // CREATOR 
  507.     0x0,                        // creation DATE for source file
  508.     noSearchForFile,            // IGNORED in Installer 4.0.x
  509.     TypeCrMustMatch,            // TYPE, CREATOR must match file on install disk
  510.     "Disk 2:splitCompTome2"        // PATH to source file        
  511. };
  512.  
  513. // • split data fork with compression
  514. // source file spec for archive containing one piece of split file 
  515. resource 'infs' (20003) {
  516.     'splt',                        // TYPE 
  517.     'heyu',                        // CREATOR 
  518.     0x0,                        // creation DATE for source file
  519.     noSearchForFile,            // IGNORED in Installer 4.0.x
  520.     TypeCrMustMatch,            // TYPE, CREATOR must match file on install disk
  521.     "Disk 2:splitCompTome3"        // PATH to source file        
  522. };
  523.  
  524. // • split - file specs
  525.  
  526. // • split resource fork with compression
  527. // shared target file spec to result from joining split pieces in archives 
  528. resource 'intf' (30000) {
  529.     format1 {
  530.         noSearchForFile,        // use default search path
  531.         TypeCrNeedNotMatch,        // target type and creator don't have to match
  532.         'ttro',                    // TYPE given to new file
  533.         'ttxt',                    // CREATOR given to new file
  534.         
  535.         0x0,                    // Target - finder flags
  536.                                 //    ( ScriptCheck fills in flags if set to 0 )
  537.         
  538.         0x1,                    // Target - creation date 
  539.         0x1,                    // Target - mod date 
  540.                                 //    ( ScriptCheck fills in dates if set to 1 )
  541.                                 
  542.         0,                        // 'insp' resource ID ( file search proc )
  543.         ":File Compression/Split Example:Example File • 3"    // path to target file
  544.     }
  545. };
  546.  
  547. // • split resource fork
  548. // source file spec for archive containing one piece of split file 
  549. resource 'infs' (30001) {
  550.     'splt',                        // TYPE 
  551.     'heyu',                        // CREATOR 
  552.     0x0,                        // creation DATE for source file
  553.     noSearchForFile,            // IGNORED in Installer 4.0.x
  554.     TypeCrMustMatch,            // TYPE, CREATOR must match file on install disk
  555.     "Disk 1:splitTome1"            // PATH to source file        
  556. };
  557.  
  558. // • split resource fork
  559. // source file spec for archive containing one piece of split file
  560. resource 'infs' (30002) {
  561.     'splt',                        // TYPE 
  562.     'heyu',                        // CREATOR 
  563.     0x0,                        // creation DATE for source file
  564.     noSearchForFile,            // IGNORED in Installer 4.0.x
  565.     TypeCrMustMatch,            // TYPE, CREATOR must match file on install disk
  566.     "Disk 2:splitTome2"            // PATH to source file        
  567. };
  568.  
  569. // • split data fork
  570. // source file spec for archive containing one piece of split file
  571. resource 'infs' (30003) {
  572.     'splt',                        // TYPE 
  573.     'heyu',                        // CREATOR 
  574.     0x0,                        // creation DATE for source file
  575.     noSearchForFile,            // IGNORED in Installer 4.0.x
  576.     TypeCrMustMatch,            // TYPE, CREATOR must match file on install disk
  577.     "Disk 2:splitTome3"            // PATH to source file        
  578. };
  579.  
  580.